// $ANTLR 3.1 plp4.g 2012-05-15 16:26:59

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class plp4Lexer extends Lexer {
    public static final int MAIN=11;
    public static final int CLASS=4;
    public static final int WHILE=28;
    public static final int CONST=17;
    public static final int NEW=35;
    public static final int STEP=31;
    public static final int FOR=29;
    public static final int MULOP=48;
    public static final int NOT=49;
    public static final int ADDOP=32;
    public static final int PARI=12;
    public static final int ID=5;
    public static final int AND=46;
    public static final int EOF=-1;
    public static final int BREAK=33;
    public static final int PARD=13;
    public static final int IF=26;
    public static final int EXPLAIN=40;
    public static final int LLAVEI=6;
    public static final int ENTERO=21;
    public static final int IN=60;
    public static final int CONTINUE=34;
    public static final int COMENTARIO=55;
    public static final int LLAVED=7;
    public static final int RETURN=41;
    public static final int DOUBLE=15;
    public static final int GET=52;
    public static final int VAR=59;
    public static final int VOID=10;
    public static final int COMENTARIOSIMPLE=56;
    public static final int EXCEPTION=39;
    public static final int READLINE=44;
    public static final int TO=30;
    public static final int PRIVATE=50;
    public static final int STATIC=9;
    public static final int ELSE=27;
    public static final int BOOL=16;
    public static final int CORD=25;
    public static final int SET=53;
    public static final int PYC=19;
    public static final int INT=14;
    public static final int COMA=18;
    public static final int TRY=37;
    public static final int PUNTO=43;
    public static final int REAL=22;
    public static final int SINGLE=57;
    public static final int PROPERTY=51;
    public static final int OR=45;
    public static final int BOOLEANO=23;
    public static final int NEWline=54;
    public static final int CORI=24;
    public static final int ASIG=20;
    public static final int FOREACH=58;
    public static final int WRITELINE=36;
    public static final int CATCH=42;
    public static final int PUBLIC=8;
    public static final int THROW=38;
    public static final int RELOP=47;

    	public void emitErrorMessage(String mensaje)
    	{
    		System.err.println(mensaje);
    		System.exit(1);
    	}


    // delegates
    // delegators

    public plp4Lexer() {;} 
    public plp4Lexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public plp4Lexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "plp4.g"; }

    // $ANTLR start "NEWline"
    public final void mNEWline() throws RecognitionException {
        try {
            int _type = NEWline;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1658:18: ( ( ( '\\r' )? '\\n' | ' ' | '\\t' )+ )
            // plp4.g:1658:20: ( ( '\\r' )? '\\n' | ' ' | '\\t' )+
            {
            // plp4.g:1658:20: ( ( '\\r' )? '\\n' | ' ' | '\\t' )+
            int cnt2=0;
            loop2:
            do {
                int alt2=4;
                switch ( input.LA(1) ) {
                case '\n':
                case '\r':
                    {
                    alt2=1;
                    }
                    break;
                case ' ':
                    {
                    alt2=2;
                    }
                    break;
                case '\t':
                    {
                    alt2=3;
                    }
                    break;

                }

                switch (alt2) {
            	case 1 :
            	    // plp4.g:1658:21: ( '\\r' )? '\\n'
            	    {
            	    // plp4.g:1658:21: ( '\\r' )?
            	    int alt1=2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0=='\r') ) {
            	        alt1=1;
            	    }
            	    switch (alt1) {
            	        case 1 :
            	            // plp4.g:1658:21: '\\r'
            	            {
            	            match('\r'); 

            	            }
            	            break;

            	    }

            	    match('\n'); 

            	    }
            	    break;
            	case 2 :
            	    // plp4.g:1658:32: ' '
            	    {
            	    match(' '); 

            	    }
            	    break;
            	case 3 :
            	    // plp4.g:1658:36: '\\t'
            	    {
            	    match('\t'); 

            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);

             skip(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEWline"

    // $ANTLR start "COMENTARIO"
    public final void mCOMENTARIO() throws RecognitionException {
        try {
            int _type = COMENTARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1659:18: ( '/*' ( . )* '*/' )
            // plp4.g:1659:20: '/*' ( . )* '*/'
            {
            match("/*"); 

            // plp4.g:1659:25: ( . )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0=='*') ) {
                    int LA3_1 = input.LA(2);

                    if ( (LA3_1=='/') ) {
                        alt3=2;
                    }
                    else if ( ((LA3_1>='\u0000' && LA3_1<='.')||(LA3_1>='0' && LA3_1<='\uFFFE')) ) {
                        alt3=1;
                    }


                }
                else if ( ((LA3_0>='\u0000' && LA3_0<=')')||(LA3_0>='+' && LA3_0<='\uFFFE')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // plp4.g:1659:25: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            match("*/"); 

            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMENTARIO"

    // $ANTLR start "COMENTARIOSIMPLE"
    public final void mCOMENTARIOSIMPLE() throws RecognitionException {
        try {
            int _type = COMENTARIOSIMPLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1661:2: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
            // plp4.g:1661:3: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
            {
            match("//"); 

            // plp4.g:1661:8: (~ ( '\\n' | '\\r' ) )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFE')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // plp4.g:1661:8: ~ ( '\\n' | '\\r' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFE') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            // plp4.g:1661:22: ( '\\r' )?
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='\r') ) {
                alt5=1;
            }
            switch (alt5) {
                case 1 :
                    // plp4.g:1661:22: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }

            match('\n'); 
            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMENTARIOSIMPLE"

    // $ANTLR start "PYC"
    public final void mPYC() throws RecognitionException {
        try {
            int _type = PYC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1662:9: ( ';' )
            // plp4.g:1662:10: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PYC"

    // $ANTLR start "ASIG"
    public final void mASIG() throws RecognitionException {
        try {
            int _type = ASIG;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1663:9: ( '=' )
            // plp4.g:1663:10: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASIG"

    // $ANTLR start "MAIN"
    public final void mMAIN() throws RecognitionException {
        try {
            int _type = MAIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1665:7: ( 'Main' )
            // plp4.g:1665:8: 'Main'
            {
            match("Main"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MAIN"

    // $ANTLR start "SINGLE"
    public final void mSINGLE() throws RecognitionException {
        try {
            int _type = SINGLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1666:8: ( 'Single' )
            // plp4.g:1666:9: 'Single'
            {
            match("Single"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SINGLE"

    // $ANTLR start "CLASS"
    public final void mCLASS() throws RecognitionException {
        try {
            int _type = CLASS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1668:9: ( 'class' )
            // plp4.g:1668:10: 'class'
            {
            match("class"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CLASS"

    // $ANTLR start "DOUBLE"
    public final void mDOUBLE() throws RecognitionException {
        try {
            int _type = DOUBLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1670:9: ( 'double' )
            // plp4.g:1670:10: 'double'
            {
            match("double"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOUBLE"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1671:9: ( 'int' )
            // plp4.g:1671:10: 'int'
            {
            match("int"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "BOOL"
    public final void mBOOL() throws RecognitionException {
        try {
            int _type = BOOL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1672:6: ( 'bool' )
            // plp4.g:1672:7: 'bool'
            {
            match("bool"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOOL"

    // $ANTLR start "VOID"
    public final void mVOID() throws RecognitionException {
        try {
            int _type = VOID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1673:9: ( 'void' )
            // plp4.g:1673:10: 'void'
            {
            match("void"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VOID"

    // $ANTLR start "PUBLIC"
    public final void mPUBLIC() throws RecognitionException {
        try {
            int _type = PUBLIC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1674:8: ( 'public' )
            // plp4.g:1674:9: 'public'
            {
            match("public"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PUBLIC"

    // $ANTLR start "STATIC"
    public final void mSTATIC() throws RecognitionException {
        try {
            int _type = STATIC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1675:8: ( 'static' )
            // plp4.g:1675:9: 'static'
            {
            match("static"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STATIC"

    // $ANTLR start "CONST"
    public final void mCONST() throws RecognitionException {
        try {
            int _type = CONST;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1676:7: ( 'const' )
            // plp4.g:1676:8: 'const'
            {
            match("const"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CONST"

    // $ANTLR start "RETURN"
    public final void mRETURN() throws RecognitionException {
        try {
            int _type = RETURN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1677:8: ( 'return' )
            // plp4.g:1677:9: 'return'
            {
            match("return"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RETURN"

    // $ANTLR start "PRIVATE"
    public final void mPRIVATE() throws RecognitionException {
        try {
            int _type = PRIVATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1678:9: ( 'private' )
            // plp4.g:1678:10: 'private'
            {
            match("private"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PRIVATE"

    // $ANTLR start "GET"
    public final void mGET() throws RecognitionException {
        try {
            int _type = GET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1679:5: ( 'get' )
            // plp4.g:1679:6: 'get'
            {
            match("get"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GET"

    // $ANTLR start "SET"
    public final void mSET() throws RecognitionException {
        try {
            int _type = SET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1680:5: ( 'set' )
            // plp4.g:1680:6: 'set'
            {
            match("set"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SET"

    // $ANTLR start "PROPERTY"
    public final void mPROPERTY() throws RecognitionException {
        try {
            int _type = PROPERTY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1681:10: ( 'property' )
            // plp4.g:1681:12: 'property'
            {
            match("property"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PROPERTY"

    // $ANTLR start "TRY"
    public final void mTRY() throws RecognitionException {
        try {
            int _type = TRY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1683:5: ( 'try' )
            // plp4.g:1683:7: 'try'
            {
            match("try"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TRY"

    // $ANTLR start "CATCH"
    public final void mCATCH() throws RecognitionException {
        try {
            int _type = CATCH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1684:7: ( 'catch' )
            // plp4.g:1684:9: 'catch'
            {
            match("catch"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CATCH"

    // $ANTLR start "EXCEPTION"
    public final void mEXCEPTION() throws RecognitionException {
        try {
            int _type = EXCEPTION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1686:2: ( 'Exception' )
            // plp4.g:1686:4: 'Exception'
            {
            match("Exception"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EXCEPTION"

    // $ANTLR start "THROW"
    public final void mTHROW() throws RecognitionException {
        try {
            int _type = THROW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1687:7: ( 'throw' )
            // plp4.g:1687:9: 'throw'
            {
            match("throw"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "THROW"

    // $ANTLR start "EXPLAIN"
    public final void mEXPLAIN() throws RecognitionException {
        try {
            int _type = EXPLAIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1688:9: ( 'explain' )
            // plp4.g:1688:11: 'explain'
            {
            match("explain"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EXPLAIN"

    // $ANTLR start "IF"
    public final void mIF() throws RecognitionException {
        try {
            int _type = IF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1691:4: ( 'if' )
            // plp4.g:1691:5: 'if'
            {
            match("if"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IF"

    // $ANTLR start "ELSE"
    public final void mELSE() throws RecognitionException {
        try {
            int _type = ELSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1692:6: ( 'else' )
            // plp4.g:1692:7: 'else'
            {
            match("else"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "FOREACH"
    public final void mFOREACH() throws RecognitionException {
        try {
            int _type = FOREACH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1693:9: ( 'foreach' )
            // plp4.g:1693:10: 'foreach'
            {
            match("foreach"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FOREACH"

    // $ANTLR start "VAR"
    public final void mVAR() throws RecognitionException {
        try {
            int _type = VAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1694:5: ( 'var' )
            // plp4.g:1694:6: 'var'
            {
            match("var"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VAR"

    // $ANTLR start "IN"
    public final void mIN() throws RecognitionException {
        try {
            int _type = IN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1695:4: ( 'in' )
            // plp4.g:1695:5: 'in'
            {
            match("in"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IN"

    // $ANTLR start "FOR"
    public final void mFOR() throws RecognitionException {
        try {
            int _type = FOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1697:5: ( 'for' )
            // plp4.g:1697:6: 'for'
            {
            match("for"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FOR"

    // $ANTLR start "TO"
    public final void mTO() throws RecognitionException {
        try {
            int _type = TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1698:4: ( 'to' )
            // plp4.g:1698:5: 'to'
            {
            match("to"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TO"

    // $ANTLR start "STEP"
    public final void mSTEP() throws RecognitionException {
        try {
            int _type = STEP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1699:6: ( 'step' )
            // plp4.g:1699:7: 'step'
            {
            match("step"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STEP"

    // $ANTLR start "WHILE"
    public final void mWHILE() throws RecognitionException {
        try {
            int _type = WHILE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1700:7: ( 'while' )
            // plp4.g:1700:8: 'while'
            {
            match("while"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHILE"

    // $ANTLR start "BREAK"
    public final void mBREAK() throws RecognitionException {
        try {
            int _type = BREAK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1701:7: ( 'break' )
            // plp4.g:1701:8: 'break'
            {
            match("break"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BREAK"

    // $ANTLR start "CONTINUE"
    public final void mCONTINUE() throws RecognitionException {
        try {
            int _type = CONTINUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1702:9: ( 'continue' )
            // plp4.g:1702:10: 'continue'
            {
            match("continue"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CONTINUE"

    // $ANTLR start "NEW"
    public final void mNEW() throws RecognitionException {
        try {
            int _type = NEW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1703:5: ( 'new' )
            // plp4.g:1703:6: 'new'
            {
            match("new"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEW"

    // $ANTLR start "WRITELINE"
    public final void mWRITELINE() throws RecognitionException {
        try {
            int _type = WRITELINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1705:2: ( 'System.Console.WriteLine' )
            // plp4.g:1705:3: 'System.Console.WriteLine'
            {
            match("System.Console.WriteLine"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WRITELINE"

    // $ANTLR start "READLINE"
    public final void mREADLINE() throws RecognitionException {
        try {
            int _type = READLINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1706:9: ( ( 'int' | 'double' | 'bool' ) '.Parse(System.Console.ReadLine())' )
            // plp4.g:1706:10: ( 'int' | 'double' | 'bool' ) '.Parse(System.Console.ReadLine())'
            {
            // plp4.g:1706:10: ( 'int' | 'double' | 'bool' )
            int alt6=3;
            switch ( input.LA(1) ) {
            case 'i':
                {
                alt6=1;
                }
                break;
            case 'd':
                {
                alt6=2;
                }
                break;
            case 'b':
                {
                alt6=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }

            switch (alt6) {
                case 1 :
                    // plp4.g:1706:11: 'int'
                    {
                    match("int"); 


                    }
                    break;
                case 2 :
                    // plp4.g:1706:17: 'double'
                    {
                    match("double"); 


                    }
                    break;
                case 3 :
                    // plp4.g:1706:26: 'bool'
                    {
                    match("bool"); 


                    }
                    break;

            }

            match(".Parse(System.Console.ReadLine())"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "READLINE"

    // $ANTLR start "PARI"
    public final void mPARI() throws RecognitionException {
        try {
            int _type = PARI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1707:9: ( '(' )
            // plp4.g:1707:10: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PARI"

    // $ANTLR start "PARD"
    public final void mPARD() throws RecognitionException {
        try {
            int _type = PARD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1708:9: ( ')' )
            // plp4.g:1708:10: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PARD"

    // $ANTLR start "LLAVEI"
    public final void mLLAVEI() throws RecognitionException {
        try {
            int _type = LLAVEI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1709:9: ( '{' )
            // plp4.g:1709:10: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LLAVEI"

    // $ANTLR start "LLAVED"
    public final void mLLAVED() throws RecognitionException {
        try {
            int _type = LLAVED;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1710:9: ( '}' )
            // plp4.g:1710:10: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LLAVED"

    // $ANTLR start "CORI"
    public final void mCORI() throws RecognitionException {
        try {
            int _type = CORI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1711:6: ( '[' )
            // plp4.g:1711:7: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CORI"

    // $ANTLR start "CORD"
    public final void mCORD() throws RecognitionException {
        try {
            int _type = CORD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1712:6: ( ']' )
            // plp4.g:1712:7: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CORD"

    // $ANTLR start "COMA"
    public final void mCOMA() throws RecognitionException {
        try {
            int _type = COMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1713:6: ( ',' )
            // plp4.g:1713:7: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMA"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1714:4: ( '|' )
            // plp4.g:1714:5: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1715:5: ( '&' )
            // plp4.g:1715:6: '&'
            {
            match('&'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "RELOP"
    public final void mRELOP() throws RecognitionException {
        try {
            int _type = RELOP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1716:7: ( '==' | '!=' | '<' | '>' | '<=' | '>=' )
            int alt7=6;
            switch ( input.LA(1) ) {
            case '=':
                {
                alt7=1;
                }
                break;
            case '!':
                {
                alt7=2;
                }
                break;
            case '<':
                {
                int LA7_3 = input.LA(2);

                if ( (LA7_3=='=') ) {
                    alt7=5;
                }
                else {
                    alt7=3;}
                }
                break;
            case '>':
                {
                int LA7_4 = input.LA(2);

                if ( (LA7_4=='=') ) {
                    alt7=6;
                }
                else {
                    alt7=4;}
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }

            switch (alt7) {
                case 1 :
                    // plp4.g:1716:8: '=='
                    {
                    match("=="); 


                    }
                    break;
                case 2 :
                    // plp4.g:1716:13: '!='
                    {
                    match("!="); 


                    }
                    break;
                case 3 :
                    // plp4.g:1716:18: '<'
                    {
                    match('<'); 

                    }
                    break;
                case 4 :
                    // plp4.g:1716:22: '>'
                    {
                    match('>'); 

                    }
                    break;
                case 5 :
                    // plp4.g:1716:26: '<='
                    {
                    match("<="); 


                    }
                    break;
                case 6 :
                    // plp4.g:1716:31: '>='
                    {
                    match(">="); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RELOP"

    // $ANTLR start "ADDOP"
    public final void mADDOP() throws RecognitionException {
        try {
            int _type = ADDOP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1717:7: ( '+' | '-' )
            // plp4.g:
            {
            if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ADDOP"

    // $ANTLR start "MULOP"
    public final void mMULOP() throws RecognitionException {
        try {
            int _type = MULOP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1718:7: ( '*' | '/' )
            // plp4.g:
            {
            if ( input.LA(1)=='*'||input.LA(1)=='/' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MULOP"

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1719:5: ( '!' )
            // plp4.g:1719:6: '!'
            {
            match('!'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "PUNTO"
    public final void mPUNTO() throws RecognitionException {
        try {
            int _type = PUNTO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1720:7: ( '.' )
            // plp4.g:1720:8: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PUNTO"

    // $ANTLR start "ENTERO"
    public final void mENTERO() throws RecognitionException {
        try {
            int _type = ENTERO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1721:9: ( ( '0' .. '9' )+ )
            // plp4.g:1721:10: ( '0' .. '9' )+
            {
            // plp4.g:1721:10: ( '0' .. '9' )+
            int cnt8=0;
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( ((LA8_0>='0' && LA8_0<='9')) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // plp4.g:1721:11: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt8 >= 1 ) break loop8;
                        EarlyExitException eee =
                            new EarlyExitException(8, input);
                        throw eee;
                }
                cnt8++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ENTERO"

    // $ANTLR start "REAL"
    public final void mREAL() throws RecognitionException {
        try {
            int _type = REAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1722:6: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )+ )
            // plp4.g:1722:7: ( '0' .. '9' )+ '.' ( '0' .. '9' )+
            {
            // plp4.g:1722:7: ( '0' .. '9' )+
            int cnt9=0;
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( ((LA9_0>='0' && LA9_0<='9')) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // plp4.g:1722:8: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt9 >= 1 ) break loop9;
                        EarlyExitException eee =
                            new EarlyExitException(9, input);
                        throw eee;
                }
                cnt9++;
            } while (true);

            match('.'); 
            // plp4.g:1722:21: ( '0' .. '9' )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>='0' && LA10_0<='9')) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // plp4.g:1722:22: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "REAL"

    // $ANTLR start "BOOLEANO"
    public final void mBOOLEANO() throws RecognitionException {
        try {
            int _type = BOOLEANO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1723:9: ( 'True' | 'False' )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0=='T') ) {
                alt11=1;
            }
            else if ( (LA11_0=='F') ) {
                alt11=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // plp4.g:1723:10: 'True'
                    {
                    match("True"); 


                    }
                    break;
                case 2 :
                    // plp4.g:1723:17: 'False'
                    {
                    match("False"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOOLEANO"

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // plp4.g:1724:9: ( ( 'a' .. 'z' | 'A' .. 'Z' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' )* )
            // plp4.g:1724:10: ( 'a' .. 'z' | 'A' .. 'Z' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' )*
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // plp4.g:1724:29: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( ((LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||(LA12_0>='a' && LA12_0<='z')) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // plp4.g:
            	    {
            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ID"

    public void mTokens() throws RecognitionException {
        // plp4.g:1:8: ( NEWline | COMENTARIO | COMENTARIOSIMPLE | PYC | ASIG | MAIN | SINGLE | CLASS | DOUBLE | INT | BOOL | VOID | PUBLIC | STATIC | CONST | RETURN | PRIVATE | GET | SET | PROPERTY | TRY | CATCH | EXCEPTION | THROW | EXPLAIN | IF | ELSE | FOREACH | VAR | IN | FOR | TO | STEP | WHILE | BREAK | CONTINUE | NEW | WRITELINE | READLINE | PARI | PARD | LLAVEI | LLAVED | CORI | CORD | COMA | OR | AND | RELOP | ADDOP | MULOP | NOT | PUNTO | ENTERO | REAL | BOOLEANO | ID )
        int alt13=57;
        alt13 = dfa13.predict(input);
        switch (alt13) {
            case 1 :
                // plp4.g:1:10: NEWline
                {
                mNEWline(); 

                }
                break;
            case 2 :
                // plp4.g:1:18: COMENTARIO
                {
                mCOMENTARIO(); 

                }
                break;
            case 3 :
                // plp4.g:1:29: COMENTARIOSIMPLE
                {
                mCOMENTARIOSIMPLE(); 

                }
                break;
            case 4 :
                // plp4.g:1:46: PYC
                {
                mPYC(); 

                }
                break;
            case 5 :
                // plp4.g:1:50: ASIG
                {
                mASIG(); 

                }
                break;
            case 6 :
                // plp4.g:1:55: MAIN
                {
                mMAIN(); 

                }
                break;
            case 7 :
                // plp4.g:1:60: SINGLE
                {
                mSINGLE(); 

                }
                break;
            case 8 :
                // plp4.g:1:67: CLASS
                {
                mCLASS(); 

                }
                break;
            case 9 :
                // plp4.g:1:73: DOUBLE
                {
                mDOUBLE(); 

                }
                break;
            case 10 :
                // plp4.g:1:80: INT
                {
                mINT(); 

                }
                break;
            case 11 :
                // plp4.g:1:84: BOOL
                {
                mBOOL(); 

                }
                break;
            case 12 :
                // plp4.g:1:89: VOID
                {
                mVOID(); 

                }
                break;
            case 13 :
                // plp4.g:1:94: PUBLIC
                {
                mPUBLIC(); 

                }
                break;
            case 14 :
                // plp4.g:1:101: STATIC
                {
                mSTATIC(); 

                }
                break;
            case 15 :
                // plp4.g:1:108: CONST
                {
                mCONST(); 

                }
                break;
            case 16 :
                // plp4.g:1:114: RETURN
                {
                mRETURN(); 

                }
                break;
            case 17 :
                // plp4.g:1:121: PRIVATE
                {
                mPRIVATE(); 

                }
                break;
            case 18 :
                // plp4.g:1:129: GET
                {
                mGET(); 

                }
                break;
            case 19 :
                // plp4.g:1:133: SET
                {
                mSET(); 

                }
                break;
            case 20 :
                // plp4.g:1:137: PROPERTY
                {
                mPROPERTY(); 

                }
                break;
            case 21 :
                // plp4.g:1:146: TRY
                {
                mTRY(); 

                }
                break;
            case 22 :
                // plp4.g:1:150: CATCH
                {
                mCATCH(); 

                }
                break;
            case 23 :
                // plp4.g:1:156: EXCEPTION
                {
                mEXCEPTION(); 

                }
                break;
            case 24 :
                // plp4.g:1:166: THROW
                {
                mTHROW(); 

                }
                break;
            case 25 :
                // plp4.g:1:172: EXPLAIN
                {
                mEXPLAIN(); 

                }
                break;
            case 26 :
                // plp4.g:1:180: IF
                {
                mIF(); 

                }
                break;
            case 27 :
                // plp4.g:1:183: ELSE
                {
                mELSE(); 

                }
                break;
            case 28 :
                // plp4.g:1:188: FOREACH
                {
                mFOREACH(); 

                }
                break;
            case 29 :
                // plp4.g:1:196: VAR
                {
                mVAR(); 

                }
                break;
            case 30 :
                // plp4.g:1:200: IN
                {
                mIN(); 

                }
                break;
            case 31 :
                // plp4.g:1:203: FOR
                {
                mFOR(); 

                }
                break;
            case 32 :
                // plp4.g:1:207: TO
                {
                mTO(); 

                }
                break;
            case 33 :
                // plp4.g:1:210: STEP
                {
                mSTEP(); 

                }
                break;
            case 34 :
                // plp4.g:1:215: WHILE
                {
                mWHILE(); 

                }
                break;
            case 35 :
                // plp4.g:1:221: BREAK
                {
                mBREAK(); 

                }
                break;
            case 36 :
                // plp4.g:1:227: CONTINUE
                {
                mCONTINUE(); 

                }
                break;
            case 37 :
                // plp4.g:1:236: NEW
                {
                mNEW(); 

                }
                break;
            case 38 :
                // plp4.g:1:240: WRITELINE
                {
                mWRITELINE(); 

                }
                break;
            case 39 :
                // plp4.g:1:250: READLINE
                {
                mREADLINE(); 

                }
                break;
            case 40 :
                // plp4.g:1:259: PARI
                {
                mPARI(); 

                }
                break;
            case 41 :
                // plp4.g:1:264: PARD
                {
                mPARD(); 

                }
                break;
            case 42 :
                // plp4.g:1:269: LLAVEI
                {
                mLLAVEI(); 

                }
                break;
            case 43 :
                // plp4.g:1:276: LLAVED
                {
                mLLAVED(); 

                }
                break;
            case 44 :
                // plp4.g:1:283: CORI
                {
                mCORI(); 

                }
                break;
            case 45 :
                // plp4.g:1:288: CORD
                {
                mCORD(); 

                }
                break;
            case 46 :
                // plp4.g:1:293: COMA
                {
                mCOMA(); 

                }
                break;
            case 47 :
                // plp4.g:1:298: OR
                {
                mOR(); 

                }
                break;
            case 48 :
                // plp4.g:1:301: AND
                {
                mAND(); 

                }
                break;
            case 49 :
                // plp4.g:1:305: RELOP
                {
                mRELOP(); 

                }
                break;
            case 50 :
                // plp4.g:1:311: ADDOP
                {
                mADDOP(); 

                }
                break;
            case 51 :
                // plp4.g:1:317: MULOP
                {
                mMULOP(); 

                }
                break;
            case 52 :
                // plp4.g:1:323: NOT
                {
                mNOT(); 

                }
                break;
            case 53 :
                // plp4.g:1:327: PUNTO
                {
                mPUNTO(); 

                }
                break;
            case 54 :
                // plp4.g:1:333: ENTERO
                {
                mENTERO(); 

                }
                break;
            case 55 :
                // plp4.g:1:340: REAL
                {
                mREAL(); 

                }
                break;
            case 56 :
                // plp4.g:1:345: BOOLEANO
                {
                mBOOLEANO(); 

                }
                break;
            case 57 :
                // plp4.g:1:354: ID
                {
                mID(); 

                }
                break;

        }

    }


    protected DFA13 dfa13 = new DFA13(this);
    static final String DFA13_eotS =
        "\2\uffff\1\42\1\uffff\1\52\21\47\11\uffff\1\107\4\uffff\1\111\2"+
        "\47\4\uffff\7\47\1\124\1\125\14\47\1\144\6\47\3\uffff\11\47\1\166"+
        "\2\uffff\3\47\1\172\5\47\1\u0080\1\47\1\u0082\1\u0083\1\47\1\uffff"+
        "\3\47\1\u0089\1\47\1\u008b\2\47\1\u008e\7\47\2\uffff\1\u0096\1\47"+
        "\1\u0098\1\uffff\4\47\1\u009d\1\uffff\1\47\2\uffff\3\47\1\u00a2"+
        "\1\47\1\uffff\1\47\1\uffff\1\u00a5\1\47\1\uffff\2\47\1\u00a9\1\u00aa"+
        "\1\47\1\u00ac\1\47\1\uffff\1\u00ae\1\uffff\4\47\1\uffff\1\47\1\u00b4"+
        "\2\47\1\uffff\1\47\1\u00b8\1\uffff\1\u00a5\1\u00b9\1\47\2\uffff"+
        "\1\47\1\uffff\1\u00bc\1\uffff\1\u00bd\2\47\1\u00c0\1\u00c1\1\uffff"+
        "\3\47\3\uffff\1\47\2\uffff\1\u00c6\1\47\2\uffff\1\47\1\u00c9\1\u00ca"+
        "\1\u00cb\1\uffff\1\u00cc\1\47\4\uffff\1\u00ce\1\uffff";
    static final String DFA13_eofS =
        "\u00cf\uffff";
    static final String DFA13_minS =
        "\1\11\1\uffff\1\52\1\uffff\1\75\1\141\1\151\1\141\1\157\1\146\1"+
        "\157\1\141\1\162\3\145\1\150\1\170\1\154\1\157\1\150\1\145\11\uffff"+
        "\1\75\4\uffff\1\56\1\162\1\141\4\uffff\1\151\1\156\1\163\1\141\1"+
        "\156\1\164\1\165\2\60\1\157\1\145\1\151\1\162\1\142\1\151\1\141"+
        "\3\164\1\171\1\162\1\60\1\143\1\160\1\163\1\162\1\151\1\167\3\uffff"+
        "\1\165\1\154\1\156\1\147\1\164\2\163\1\143\1\142\1\56\2\uffff\1"+
        "\154\1\141\1\144\1\60\1\154\1\166\1\160\1\164\1\160\1\60\1\165\2"+
        "\60\1\157\1\uffff\1\145\1\154\1\145\1\60\1\154\1\60\1\145\1\163"+
        "\1\60\1\154\1\145\1\163\1\164\1\151\1\150\1\154\2\uffff\1\56\1\153"+
        "\1\60\1\uffff\1\151\1\141\1\145\1\151\1\60\1\uffff\1\162\2\uffff"+
        "\1\167\1\160\1\141\1\60\1\141\1\uffff\1\145\1\uffff\1\60\1\145\1"+
        "\uffff\1\145\1\155\2\60\1\156\1\60\1\145\1\uffff\1\60\1\uffff\1"+
        "\143\1\164\1\162\1\143\1\uffff\1\156\1\60\1\164\1\151\1\uffff\1"+
        "\143\1\60\1\uffff\2\60\1\56\2\uffff\1\165\1\uffff\1\56\1\uffff\1"+
        "\60\1\145\1\164\2\60\1\uffff\1\151\1\156\1\150\3\uffff\1\145\2\uffff"+
        "\1\60\1\171\2\uffff\1\157\3\60\1\uffff\1\60\1\156\4\uffff\1\60\1"+
        "\uffff";
    static final String DFA13_maxS =
        "\1\175\1\uffff\1\57\1\uffff\1\75\1\141\1\171\2\157\1\156\1\162\1"+
        "\157\1\165\1\164\2\145\1\162\2\170\1\157\1\150\1\145\11\uffff\1"+
        "\75\4\uffff\1\71\1\162\1\141\4\uffff\1\151\1\156\1\163\1\141\1\156"+
        "\1\164\1\165\2\172\1\157\1\145\1\151\1\162\1\142\1\157\1\145\3\164"+
        "\1\171\1\162\1\172\1\143\1\160\1\163\1\162\1\151\1\167\3\uffff\1"+
        "\165\1\154\1\156\1\147\1\164\1\163\1\164\1\143\1\142\1\172\2\uffff"+
        "\1\154\1\141\1\144\1\172\1\154\1\166\1\160\1\164\1\160\1\172\1\165"+
        "\2\172\1\157\1\uffff\1\145\1\154\1\145\1\172\1\154\1\172\1\145\1"+
        "\163\1\172\1\154\1\145\1\163\1\164\1\151\1\150\1\154\2\uffff\1\172"+
        "\1\153\1\172\1\uffff\1\151\1\141\1\145\1\151\1\172\1\uffff\1\162"+
        "\2\uffff\1\167\1\160\1\141\1\172\1\141\1\uffff\1\145\1\uffff\1\172"+
        "\1\145\1\uffff\1\145\1\155\2\172\1\156\1\172\1\145\1\uffff\1\172"+
        "\1\uffff\1\143\1\164\1\162\1\143\1\uffff\1\156\1\172\1\164\1\151"+
        "\1\uffff\1\143\1\172\1\uffff\2\172\1\56\2\uffff\1\165\1\uffff\1"+
        "\172\1\uffff\1\172\1\145\1\164\2\172\1\uffff\1\151\1\156\1\150\3"+
        "\uffff\1\145\2\uffff\1\172\1\171\2\uffff\1\157\3\172\1\uffff\1\172"+
        "\1\156\4\uffff\1\172\1\uffff";
    static final String DFA13_acceptS =
        "\1\uffff\1\1\1\uffff\1\4\22\uffff\1\50\1\51\1\52\1\53\1\54\1\55"+
        "\1\56\1\57\1\60\1\uffff\1\61\1\62\1\63\1\65\3\uffff\1\71\1\2\1\3"+
        "\1\5\34\uffff\1\64\1\67\1\66\12\uffff\1\36\1\32\16\uffff\1\40\20"+
        "\uffff\1\47\1\12\3\uffff\1\35\5\uffff\1\23\1\uffff\1\22\1\25\5\uffff"+
        "\1\37\1\uffff\1\45\2\uffff\1\6\7\uffff\1\13\1\uffff\1\14\4\uffff"+
        "\1\41\4\uffff\1\33\2\uffff\1\70\3\uffff\1\10\1\17\1\uffff\1\26\1"+
        "\uffff\1\43\5\uffff\1\30\3\uffff\1\42\1\7\1\46\1\uffff\1\11\1\15"+
        "\2\uffff\1\16\1\20\4\uffff\1\21\2\uffff\1\31\1\34\1\44\1\24\1\uffff"+
        "\1\27";
    static final String DFA13_specialS =
        "\u00cf\uffff}>";
    static final String[] DFA13_transitionS = {
            "\2\1\2\uffff\1\1\22\uffff\1\1\1\37\4\uffff\1\36\1\uffff\1\26"+
            "\1\27\1\42\1\41\1\34\1\41\1\43\1\2\12\44\1\uffff\1\3\1\40\1"+
            "\4\1\40\2\uffff\4\47\1\21\1\46\6\47\1\5\5\47\1\6\1\45\6\47\1"+
            "\32\1\uffff\1\33\3\uffff\1\47\1\12\1\7\1\10\1\22\1\23\1\17\1"+
            "\47\1\11\4\47\1\25\1\47\1\14\1\47\1\16\1\15\1\20\1\47\1\13\1"+
            "\24\3\47\1\30\1\35\1\31",
            "",
            "\1\50\4\uffff\1\51",
            "",
            "\1\40",
            "\1\53",
            "\1\54\17\uffff\1\55",
            "\1\60\12\uffff\1\56\2\uffff\1\57",
            "\1\61",
            "\1\63\7\uffff\1\62",
            "\1\64\2\uffff\1\65",
            "\1\67\15\uffff\1\66",
            "\1\71\2\uffff\1\70",
            "\1\73\16\uffff\1\72",
            "\1\74",
            "\1\75",
            "\1\77\6\uffff\1\100\2\uffff\1\76",
            "\1\101",
            "\1\103\13\uffff\1\102",
            "\1\104",
            "\1\105",
            "\1\106",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\40",
            "",
            "",
            "",
            "",
            "\1\110\1\uffff\12\44",
            "\1\112",
            "\1\113",
            "",
            "",
            "",
            "",
            "\1\114",
            "\1\115",
            "\1\116",
            "\1\117",
            "\1\120",
            "\1\121",
            "\1\122",
            "\12\47\7\uffff\32\47\6\uffff\23\47\1\123\6\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\126",
            "\1\127",
            "\1\130",
            "\1\131",
            "\1\132",
            "\1\133\5\uffff\1\134",
            "\1\135\3\uffff\1\136",
            "\1\137",
            "\1\140",
            "\1\141",
            "\1\142",
            "\1\143",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\145",
            "\1\146",
            "\1\147",
            "\1\150",
            "\1\151",
            "\1\152",
            "",
            "",
            "",
            "\1\153",
            "\1\154",
            "\1\155",
            "\1\156",
            "\1\157",
            "\1\160",
            "\1\161\1\162",
            "\1\163",
            "\1\164",
            "\1\165\1\uffff\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "",
            "\1\167",
            "\1\170",
            "\1\171",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\173",
            "\1\174",
            "\1\175",
            "\1\176",
            "\1\177",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u0081",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u0084",
            "",
            "\1\u0085",
            "\1\u0086",
            "\1\u0087",
            "\12\47\7\uffff\32\47\6\uffff\4\47\1\u0088\25\47",
            "\1\u008a",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u008c",
            "\1\u008d",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u008f",
            "\1\u0090",
            "\1\u0091",
            "\1\u0092",
            "\1\u0093",
            "\1\u0094",
            "\1\u0095",
            "",
            "",
            "\1\165\1\uffff\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u0097",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\1\u0099",
            "\1\u009a",
            "\1\u009b",
            "\1\u009c",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\1\u009e",
            "",
            "",
            "\1\u009f",
            "\1\u00a0",
            "\1\u00a1",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00a3",
            "",
            "\1\u00a4",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00a6",
            "",
            "\1\u00a7",
            "\1\u00a8",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00ab",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00ad",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\1\u00af",
            "\1\u00b0",
            "\1\u00b1",
            "\1\u00b2",
            "",
            "\1\u00b3",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00b5",
            "\1\u00b6",
            "",
            "\1\u00b7",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00ba",
            "",
            "",
            "\1\u00bb",
            "",
            "\1\165\1\uffff\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00be",
            "\1\u00bf",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\1\u00c2",
            "\1\u00c3",
            "\1\u00c4",
            "",
            "",
            "",
            "\1\u00c5",
            "",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00c7",
            "",
            "",
            "\1\u00c8",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            "\1\u00cd",
            "",
            "",
            "",
            "",
            "\12\47\7\uffff\32\47\6\uffff\32\47",
            ""
    };

    static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
    static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
    static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
    static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
    static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
    static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
    static final short[][] DFA13_transition;

    static {
        int numStates = DFA13_transitionS.length;
        DFA13_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
        }
    }

    class DFA13 extends DFA {

        public DFA13(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 13;
            this.eot = DFA13_eot;
            this.eof = DFA13_eof;
            this.min = DFA13_min;
            this.max = DFA13_max;
            this.accept = DFA13_accept;
            this.special = DFA13_special;
            this.transition = DFA13_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( NEWline | COMENTARIO | COMENTARIOSIMPLE | PYC | ASIG | MAIN | SINGLE | CLASS | DOUBLE | INT | BOOL | VOID | PUBLIC | STATIC | CONST | RETURN | PRIVATE | GET | SET | PROPERTY | TRY | CATCH | EXCEPTION | THROW | EXPLAIN | IF | ELSE | FOREACH | VAR | IN | FOR | TO | STEP | WHILE | BREAK | CONTINUE | NEW | WRITELINE | READLINE | PARI | PARD | LLAVEI | LLAVED | CORI | CORD | COMA | OR | AND | RELOP | ADDOP | MULOP | NOT | PUNTO | ENTERO | REAL | BOOLEANO | ID );";
        }
    }
 

}